<?php
/**
 * Utilities
 * 
 * $Rev: 8 $
 * $Author: thejahweh $
 * $Date: 2010-09-14 09:40:11 +0200 (Di, 14 Sep 2010) $
 * $Id: u.class.php 8 2010-09-14 07:40:11Z thejahweh $
 * $URL: https://allone.googlecode.com/svn/trunk/plugins/core/u.class.php $
 * @author: Adrian Liechti <info@jahweh.ch>
 * @copyright: 2010 Adrian Liechti, GPL3 and CC3 BY-SA
 */

class u {
	
	public static $o				= array();
	public static $oGroup			= array();
	public static $oCache			= false;
	public static $oVisGr			= false;
	protected static $invisibleA	= "<?php /*\n";
	protected static $invisibleAC	= 9;
	protected static $invisibleZ	= "\n*/?>";
	protected static $invisibleZC	= -5;
	
	private function __construct () {
		
	}
	
	/**
	 * Trace Ausgabe Funktion, o = Output
	 * @param string $str
	 * @param string $group
	 * @param int $leftSpan
	 * @param string $span
	 * @return bool
	 */
	public static function o ($str, $group = false, $leftSpan = 0, $span = '   ') {
		if (is_array(self::$oGroup) === false or in_array($group, self::$oGroup)) {
			return false;
		} else {
			if (self::$oCache === true) {
				self::$o[] = array($str, $group, $leftSpan);
			} elseif ($str !== false) {
				echo str_repeat($span, $leftSpan).strip_tags($str).(self::$oVisGr ? ' ('.$group.')' : '')."\n";
			}
			return true;
		}
	}
	
	/**
	 * Ermittelt erneut die Länge von $invisibleA und $invisibleZ
	 * @return none
	 */
	public static function refreshInvisibleCount () {
		self::$invisibleAC = strlen(self::$invisibleA);
		self::$invisibleZC = strlen(self::$invisibleZ) * -1;
	}
	
	/**
	 * Lädt eine unsichtbare Datei, mit hilfe von loadInvisibleFileExtended.
	 * Dabei wird $invisibleAC als Anfang und $invisibleZC als Ende benutzt.
	 * @param path $fpath
	 * @return string
	 */
	public static function loadInvisibleFile ($fpath) {
		return substr(file_get_contents($fpath), self::$invisibleAC, self::$invisibleZC);
	}
	
	/**
	 * Ladet eine unsichtbare Datei mit erweiterten Funktionen.
	 * $a ist der Anfang der Datei, der entfernt werden sollte.
	 * $b ist das Ende der Datei, was entfernt werden sollte.
	 * Bei $a|$b = NULL wird die länge von $invisibleA|Z ermittelt und am Anfang|Ende entfernt.
	 * Bei $a|$b = false wird $invisibleAC|ZC als länge benutzt und am Anfang|Ende entfernt.
	 * Bei $a|$b = String wird die länge vom String ermittelt und am Anfang|Ende entfernt.
	 * @param path $fpath
	 * @param string|NULL|false $a
	 * @param string|NULL|false $z
	 * @return String
	 */
	public static function loadInvisibleFileExtended ($fpath, $a = false, $z = false) {
		$cont = file_get_contents($fpath);
		if ($a === NULL) {
			$a = strlen(self::$invisibleA);
		} elseif ($a === false) {
			$a = self::$invisibleAC;
		} elseif (is_string($a)) {
			$a = strpos($cont, $a);
		}
		if ($z === NULL) {
			$z = strlen(self::$invisibleZ);
		} elseif ($z === false) {
			$z = self::$invisibleZC;
		} elseif (is_string($z)) {
			$z = strrpos($cont, $z);
		}
		return substr($cont, $a, $z);
	}
	
	/**
	 * Ladet eine unsichtbare DOM-XML-Datei
	 * @param path $fpath
	 * @return DomDocument
	 */
	public static function loadInvisibleDOMXMLFile ($fpath) {
		$dom = new DomDocument('1.0', 'utf-8');
		$dom->loadXML(self::loadInvisibleFile($fpath));
		return $dom;
	}
	
	/**
	 * Ladet eine unsichtbare XML-Datei
	 * Benutzt die Funktionen loadInvisibleFile und bei Fehler loadInvisibleFileExtended
	 * @param path $fpath
	 * @return simplexml
	 */
	public static function loadInvisibleSimpleXMLFile ($fpath) {
		/**
		 * TODO Fehlerausgabe, bei falschgeladenem InvisibleSimpleXMLFile!
		 */
		if ($cont = @simplexml_load_string(self::loadInvisibleFile($fpath))) {
			return $cont;
		} else {
			/**
			 * TODO Verbesserte XML-Erkennung, bei falschgeladenem InvisibleSimpleXMLFile!
			 */
			return simplexml_load_string(self::loadInvisibleFileExtended($fpath, '<?xml'));
		}
	}
	
	/**
	 * Ladet eine unsichtbare Datei in eine Konfigurationsklasse.
	 * Prüft zu erst ob die Datei existiert und ladet die datei.
	 * Wenn sie nicht existiert, wird geprüft ob $str !== false ist und lädt eine CFG-Klasse
	 * mit dem in $str enthaltenen String, andernfalls wird false zurückgegeben.
	 * @param path $fpath
	 * @param string $str
	 * @return CFG-Class|false
	 */
	public static function loadInvisibleCFG ($fpath, $str = false) {
		if (file_exists($fpath)) {
			$cfg = new cfg(self::loadInvisibleFile($fpath));
			$cfg->setRoot($fpath);
		} elseif ($str !== false) {
			$cfg = new cfg($str);
			$cfg->setRoot($fpath);
		} else {
			$cfg = false;
		}
		return $cfg;
	}
	
	/**
	 * Speichert einen String in eine unsichtbare Datei.
	 * @param path $fpath
	 * @param string $data
	 * @return bool
	 */
	public static function saveInvisibleFile ($fpath, $data) {
		return file_put_contents($fpath, self::$invisibleA.$data.self::$invisibleZ);
	}
	
	/**
	 * Gibt Variablentypen zu true,false,null,empty,array,object aus, andernfalls den String.
	 * @param all $to
	 * @return string
	 */
	public static function xToStr ($to) {
		if ($to === true) {
			return 'true';
		} elseif ($to === false) {
			return 'false';
		} elseif ($to === NULL) {
			return 'null';
		} elseif (empty($to)) {
			return 'empty';
		} elseif (is_array($to)) {
			return 'array';
		} elseif (is_object($to)) {
			return 'object';
		} else {
			return $to;
		}
	}
	
	public static function xmlTrue ($xml) {
		return ($xml == '1' ? true : false);
	}
	
	/**
	 * Prüft ob ein String am Ende eines Strings vor kommt, gut für die Dateiendungserkennung.
	 * @param string $str
	 * @param string $ext
	 * @return bool
	 */
	public static function isStrEnd ($str, $ext) {
		return strripos($str, $ext) + strlen($ext) == strlen($str);
	}
	
	/**
	 * Gibt den Ausgabepfad zum jeweiligen Plugin zurück.
	 * @param string $outputName
	 * @return array(path,dir)|false
	 */
	public static function getOutputPath ($outputName) {
		global $pluginLoader;
		if ($output = explode(':', $outputName, 2)) {
			if (is_object($pluginLoader->$output[0])) {
				if (count($output) === 2) {
					$outputXML =& $pluginLoader->$output[0]->getRegisterXpath('child::output[attribute::name="'.$output[1].'"]');
				} else {
					$outputXML =& $pluginLoader->$output[0]->register->output;
				}
				if ($outputXML !== NULL) {
					return array('path' => (string)$outputXML['path'], 'dir' => $pluginLoader->$output[0]->dir);
				} else {
					return false;
				}
			}
		}
	}
	
	public static function callRegisterFunctions ($name) {
		global $pluginLoader;
		if (isset($pluginLoader->register->$name) === false) return false;
		foreach ($pluginLoader->register->$name as $r) {
			if (isset($r['name'], $r['path'])) {
				include_once($pluginLoader->plugins[(string)$r['pluginName']]->dir.'/'.$r['path']);
				call_user_func((string)$r['name']);
			}
		}
		return true;
	}
	
	
	
}


//u::refreshInvisibleCount();


?>